{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This mounts your Google Drive to the Colab VM.\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive', force_remount=True)\n",
    "\n",
    "# Enter the foldername in your Drive where you have saved the unzipped\n",
    "# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n",
    "FOLDERNAME = None\n",
    "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
    "\n",
    "# Now that we've mounted your Drive, this ensures that\n",
    "# the Python interpreter of the Colab VM can load\n",
    "# python files from within it.\n",
    "import sys\n",
    "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
    "\n",
    "# This downloads the CIFAR-10 dataset to your Drive\n",
    "# if it doesn't already exist.\n",
    "%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
    "!bash get_datasets.sh\n",
    "%cd /content/drive/My\\ Drive/$FOLDERNAME"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.320838\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ 由于权值是随机选取的，因此对每一类的预测值应均为0.1。因此输出loss应接近 $-log(0.1)$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -0.647707 analytic: -0.647707, relative error: 5.077263e-08\n",
      "numerical: 1.087794 analytic: 1.087794, relative error: 5.302870e-08\n",
      "numerical: -0.311402 analytic: -0.311403, relative error: 6.111232e-08\n",
      "numerical: 0.128527 analytic: 0.128527, relative error: 1.878046e-08\n",
      "numerical: -3.298392 analytic: -3.298392, relative error: 2.016585e-08\n",
      "numerical: 0.390039 analytic: 0.390039, relative error: 1.279751e-07\n",
      "numerical: 0.172680 analytic: 0.172680, relative error: 1.494160e-07\n",
      "numerical: 0.438113 analytic: 0.438113, relative error: 2.480712e-10\n",
      "numerical: -0.849838 analytic: -0.849838, relative error: 4.475000e-08\n",
      "numerical: -1.048529 analytic: -1.048529, relative error: 1.858336e-08\n",
      "numerical: 0.457163 analytic: 0.457163, relative error: 5.779561e-08\n",
      "numerical: 0.041092 analytic: 0.041092, relative error: 9.319632e-07\n",
      "numerical: 1.251763 analytic: 1.251763, relative error: 2.317255e-08\n",
      "numerical: 2.219268 analytic: 2.219268, relative error: 1.361495e-08\n",
      "numerical: -1.190484 analytic: -1.190484, relative error: 1.064505e-09\n",
      "numerical: -0.734932 analytic: -0.734932, relative error: 3.380960e-08\n",
      "numerical: 0.384002 analytic: 0.384002, relative error: 6.648219e-08\n",
      "numerical: -0.140919 analytic: -0.140919, relative error: 4.319803e-07\n",
      "numerical: 1.721727 analytic: 1.721727, relative error: 9.954729e-09\n",
      "numerical: 0.469116 analytic: 0.469115, relative error: 5.954582e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.320838e+00 computed in 0.110975s\n",
      "vectorized loss: 2.320838e+00 computed in 0.004992s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "tuning",
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_acc:0.34491836734693876  val_acc:0.351\n",
      "train_acc:0.34946938775510206  val_acc:0.347\n",
      "train_acc:0.35289795918367345  val_acc:0.354\n",
      "train_acc:0.36042857142857143  val_acc:0.377\n",
      "train_acc:0.3587959183673469  val_acc:0.37\n",
      "train_acc:0.3619591836734694  val_acc:0.354\n",
      "train_acc:0.3659591836734694  val_acc:0.364\n",
      "train_acc:0.3296122448979592  val_acc:0.348\n",
      "train_acc:0.3295918367346939  val_acc:0.337\n",
      "train_acc:0.32808163265306123  val_acc:0.343\n",
      "train_acc:0.328734693877551  val_acc:0.34\n",
      "train_acc:0.32946938775510204  val_acc:0.338\n",
      "train_acc:0.3293469387755102  val_acc:0.34\n",
      "train_acc:0.33455102040816326  val_acc:0.347\n",
      "train_acc:0.3784489795918367  val_acc:0.393\n",
      "train_acc:0.3789183673469388  val_acc:0.388\n",
      "train_acc:0.37757142857142856  val_acc:0.388\n",
      "train_acc:0.3749387755102041  val_acc:0.391\n",
      "train_acc:0.37326530612244896  val_acc:0.394\n",
      "train_acc:0.3676122448979592  val_acc:0.382\n",
      "train_acc:0.36820408163265306  val_acc:0.373\n",
      "train_acc:0.33279591836734695  val_acc:0.351\n",
      "train_acc:0.33448979591836736  val_acc:0.347\n",
      "train_acc:0.3290612244897959  val_acc:0.348\n",
      "train_acc:0.33024489795918366  val_acc:0.349\n",
      "train_acc:0.32387755102040816  val_acc:0.335\n",
      "train_acc:0.32363265306122446  val_acc:0.335\n",
      "train_acc:0.3259795918367347  val_acc:0.331\n",
      "train_acc:0.37918367346938775  val_acc:0.389\n",
      "train_acc:0.37542857142857144  val_acc:0.392\n",
      "train_acc:0.37073469387755104  val_acc:0.378\n",
      "train_acc:0.3699183673469388  val_acc:0.383\n",
      "train_acc:0.36789795918367346  val_acc:0.377\n",
      "train_acc:0.3696122448979592  val_acc:0.383\n",
      "train_acc:0.3637755102040816  val_acc:0.378\n",
      "train_acc:0.32671428571428573  val_acc:0.357\n",
      "train_acc:0.32948979591836736  val_acc:0.345\n",
      "train_acc:0.3159183673469388  val_acc:0.333\n",
      "train_acc:0.32210204081632654  val_acc:0.333\n",
      "train_acc:0.3101632653061224  val_acc:0.328\n",
      "train_acc:0.32802040816326533  val_acc:0.34\n",
      "train_acc:0.3298979591836735  val_acc:0.346\n",
      "lr 1.000000e-07 reg 7.000000e+03 train accuracy: 0.344918 val accuracy: 0.351000\n",
      "lr 1.000000e-07 reg 8.000000e+03 train accuracy: 0.349469 val accuracy: 0.347000\n",
      "lr 1.000000e-07 reg 9.000000e+03 train accuracy: 0.352898 val accuracy: 0.354000\n",
      "lr 1.000000e-07 reg 1.000000e+04 train accuracy: 0.360429 val accuracy: 0.377000\n",
      "lr 1.000000e-07 reg 1.100000e+04 train accuracy: 0.358796 val accuracy: 0.370000\n",
      "lr 1.000000e-07 reg 1.200000e+04 train accuracy: 0.361959 val accuracy: 0.354000\n",
      "lr 1.000000e-07 reg 1.300000e+04 train accuracy: 0.365959 val accuracy: 0.364000\n",
      "lr 1.000000e-07 reg 4.700000e+04 train accuracy: 0.329612 val accuracy: 0.348000\n",
      "lr 1.000000e-07 reg 4.800000e+04 train accuracy: 0.329592 val accuracy: 0.337000\n",
      "lr 1.000000e-07 reg 4.900000e+04 train accuracy: 0.328082 val accuracy: 0.343000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.328735 val accuracy: 0.340000\n",
      "lr 1.000000e-07 reg 5.100000e+04 train accuracy: 0.329469 val accuracy: 0.338000\n",
      "lr 1.000000e-07 reg 5.200000e+04 train accuracy: 0.329347 val accuracy: 0.340000\n",
      "lr 1.000000e-07 reg 5.300000e+04 train accuracy: 0.334551 val accuracy: 0.347000\n",
      "lr 2.000000e-07 reg 7.000000e+03 train accuracy: 0.378449 val accuracy: 0.393000\n",
      "lr 2.000000e-07 reg 8.000000e+03 train accuracy: 0.378918 val accuracy: 0.388000\n",
      "lr 2.000000e-07 reg 9.000000e+03 train accuracy: 0.377571 val accuracy: 0.388000\n",
      "lr 2.000000e-07 reg 1.000000e+04 train accuracy: 0.374939 val accuracy: 0.391000\n",
      "lr 2.000000e-07 reg 1.100000e+04 train accuracy: 0.373265 val accuracy: 0.394000\n",
      "lr 2.000000e-07 reg 1.200000e+04 train accuracy: 0.367612 val accuracy: 0.382000\n",
      "lr 2.000000e-07 reg 1.300000e+04 train accuracy: 0.368204 val accuracy: 0.373000\n",
      "lr 2.000000e-07 reg 4.700000e+04 train accuracy: 0.332796 val accuracy: 0.351000\n",
      "lr 2.000000e-07 reg 4.800000e+04 train accuracy: 0.334490 val accuracy: 0.347000\n",
      "lr 2.000000e-07 reg 4.900000e+04 train accuracy: 0.329061 val accuracy: 0.348000\n",
      "lr 2.000000e-07 reg 5.000000e+04 train accuracy: 0.330245 val accuracy: 0.349000\n",
      "lr 2.000000e-07 reg 5.100000e+04 train accuracy: 0.323878 val accuracy: 0.335000\n",
      "lr 2.000000e-07 reg 5.200000e+04 train accuracy: 0.323633 val accuracy: 0.335000\n",
      "lr 2.000000e-07 reg 5.300000e+04 train accuracy: 0.325980 val accuracy: 0.331000\n",
      "lr 5.000000e-07 reg 7.000000e+03 train accuracy: 0.379184 val accuracy: 0.389000\n",
      "lr 5.000000e-07 reg 8.000000e+03 train accuracy: 0.375429 val accuracy: 0.392000\n",
      "lr 5.000000e-07 reg 9.000000e+03 train accuracy: 0.370735 val accuracy: 0.378000\n",
      "lr 5.000000e-07 reg 1.000000e+04 train accuracy: 0.369918 val accuracy: 0.383000\n",
      "lr 5.000000e-07 reg 1.100000e+04 train accuracy: 0.367898 val accuracy: 0.377000\n",
      "lr 5.000000e-07 reg 1.200000e+04 train accuracy: 0.369612 val accuracy: 0.383000\n",
      "lr 5.000000e-07 reg 1.300000e+04 train accuracy: 0.363776 val accuracy: 0.378000\n",
      "lr 5.000000e-07 reg 4.700000e+04 train accuracy: 0.326714 val accuracy: 0.357000\n",
      "lr 5.000000e-07 reg 4.800000e+04 train accuracy: 0.329490 val accuracy: 0.345000\n",
      "lr 5.000000e-07 reg 4.900000e+04 train accuracy: 0.315918 val accuracy: 0.333000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.322102 val accuracy: 0.333000\n",
      "lr 5.000000e-07 reg 5.100000e+04 train accuracy: 0.310163 val accuracy: 0.328000\n",
      "lr 5.000000e-07 reg 5.200000e+04 train accuracy: 0.328020 val accuracy: 0.340000\n",
      "lr 5.000000e-07 reg 5.300000e+04 train accuracy: 0.329898 val accuracy: 0.346000\n",
      "best validation accuracy achieved during cross-validation: 0.394000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "# learning_rates = [1e-7, 5e-7]\n",
    "# regularization_strengths = [2.5e4, 5e4]\n",
    "learning_rates = [1e-7, 2e-7, 5e-7]\n",
    "regularization_strengths =[(1+0.1*i)*1e4 for i in range(-3,4)] + [(5+0.1*i)*1e4 for i in range(-3,4)]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        softmax.train(X_train,y_train,lr,rs,num_iters=2000)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        train_acc = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        val_acc = np.mean(y_val == y_val_pred)\n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_softmax = softmax\n",
    "        results[(lr,rs)] = train_acc,val_acc\n",
    "        print(\"train_acc:{}  val_acc:{}\".format(train_acc,val_acc))\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.374000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
